PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/code/r3keyfr2.js

JavaScript | 2005-04-04 | 26.8 KB | 836 lines

// JavaScript wrapper for r3keyfr2.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_KEYFRAME2_H = 1;
include("real/code/r3chory.js")


var R3CLID_KEYFRAME2 = 221;




// Description: Add new tag to be animated
// p1: Boolean, if true, no curves are created (caller will create anim curves later)

R3KFRMM_ADDTAG = 221000;

function mR3KFRMM_ADDTAG(p1) {
  DoA2(this.r3obj, 221000, p1, R3TID_BOOLEAN, 0, 0, R3TID_INTEGER, 0);
}

// Description: See if the given attribute is animated.
// Returns: Object, animated attribute
// p1: Integer, attribute identifier
// p3: Integer, attribute index, or -1 for regular attributes

R3KFRMM_TAGISANIMATED = 221001;

function mR3KFRMM_TAGISANIMATED(p1, p3) {
  return R3ToJS(  DoA2(this.r3obj, 221001, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0));
}

// Description: Update the attribute value of the current choreography.
// p1: Integer, attribute id
// p2: Integer, attribute index for indexed attrs, -1 for regular attrs
// p3: Object, new value of the attribute

R3KFRMM_TAGCHANGED = 221002;

function mR3KFRMM_TAGCHANGED(p1, p2, p3) {
  DoA3(this.r3obj, 221002, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_OBJECT, 0);
}

// Description: Set new time
// p1: Boolean, disable recalc (only set time).
// p3: Number, new time

R3KFRMM_NEWTIME = 221003;

function mR3KFRMM_NEWTIME(p1, p3) {
  DoA2(this.r3obj, 221003, p1, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Set new time for the given choreography.
// Returns: Boolean, true if succeeded
// p1: Integer, chor index
// p3: Number, new time value

R3KFRMM_NEWCHOREOGRAPHYTIME = 221004;

function mR3KFRMM_NEWCHOREOGRAPHYTIME(p1, p3) {
  return   DoA2(this.r3obj, 221004, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Make the choreography not time dependent. See also R3KFRMM_SETINPUT method,    * for seting input to
//      desired object/attribute.
// Returns: Boolean, true if chor index was valid
// p3: Integer, chor index

R3KFRMM_SETTIMEOVERRIDE = 221005;

function mR3KFRMM_SETTIMEOVERRIDE(p3) {
  return   DoA(this.r3obj, 221005, p3, R3TID_INTEGER, 0);
}

// Description: Make the choreography time dependent.
// Returns: Boolean, true if chor index was valid
// p3: Integer, chor index

R3KFRMM_UNSETTIMEOVERRIDE = 221006;

function mR3KFRMM_UNSETTIMEOVERRIDE(p3) {
  return   DoA(this.r3obj, 221006, p3, R3TID_INTEGER, 0);
}

// Description: Delete animated attribute object and associated choreographs.
// Returns: Boolean, true if attribute was animated.
// p1: Integer, attribute indentifier
// p3: Integer, attribute index or -1 for regular attributes

R3KFRMM_REMOVETAG = 221007;

function mR3KFRMM_REMOVETAG(p1, p3) {
  return   DoA2(this.r3obj, 221007, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Fetch the keyframe curve object. Note: returns NULL if    * the choreography is not a
//      key framer, or if the attribute * is not key framed.
// Returns: Object, curve object
// p1: Integer, chor index
// p2: Integer, attribute id
// p3: Integer, attribute index, or -1 for regular attrs.

R3KFRMM_GETCURVE = 221008;

function mR3KFRMM_GETCURVE(p1, p2, p3) {
  return R3ToJS(  DoA3(this.r3obj, 221008, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0));
}

// Description: Recalculate animated tag.
// p1: Boolean, restore all origvals
// p3: Integer, tag to be recalculated

R3KFRMM_RECALCTAG = 221009;

function mR3KFRMM_RECALCTAG(p1, p3) {
  DoA2(this.r3obj, 221009, p1, R3TID_BOOLEAN, 0, p3, R3TID_INTEGER, 0);
}

// Description: See if the default choreography input (time) has been overridden
// Returns: Boolean, TRUE if overridden (that is, input is not time).
// p3: Integer, chor index

R3KFRMM_TIMEOVERRIDE = 221010;

function mR3KFRMM_TIMEOVERRIDE(p3) {
  return   DoA(this.r3obj, 221010, p3, R3TID_INTEGER, 0);
}

// Description: Change the size of the array attribute.
// p1: Integer, attribute id
// p2: Integer, attribute index, or -1 for regular attrs
// p3: Integer, new array size.

R3KFRMM_CHANGENUMVALSFORTAG = 221011;

function mR3KFRMM_CHANGENUMVALSFORTAG(p1, p2, p3) {
  DoA3(this.r3obj, 221011, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Enumerate animation curves for a given choreography.

R3KFRMM_ENUMCURVES = 221012;

function mR3KFRMM_ENUMCURVES() {
  DoA(this.r3obj, 221012, 0, R3TID_INTEGER, 0);
}

// Description: Change the tag id and index of given choreography.
// p1: Integer, tag
// p2: Integer, index,
// p3: Tag[], R3KFRMA_Tag, R3KFRMA_Index: New tag id and new index.

R3KFRMM_CHANGETAGID = 221013;

function mR3KFRMM_CHANGETAGID(p1, p2, p3) {
  Do3(this.r3obj, 221013, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Set origvals for the attribute specified by 'tag' and 'index'.
// Virtual method
// p1: Integer, tag
// p2: Integer, index
// p3: Object, new origvals.

R3KFRMM_SETORIGVAL = 221014;

function mR3KFRMM_SETORIGVAL(p1, p2, p3) {
  DoA3(this.r3obj, 221014, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_OBJECT, 0);
}

// Description: Fetch the orig val.

R3KFRMM_GETORIGVAL = 221015;

function mR3KFRMM_GETORIGVAL() {
  DoA(this.r3obj, 221015, 0, R3TID_INTEGER, 0);
}

// Description: Create choreography objects for all the animated tags.

R3KFRMM_MAKECHOROBJECTS = 221016;

function mR3KFRMM_MAKECHOROBJECTS() {
  DoA(this.r3obj, 221016, 0, R3TID_INTEGER, 0);
}

// Description: Find chor object corresponding the given ordnum
// Returns: Object, chor object or NULL if not found
// p1: Object, animated tag if attr specific chor, otherwise NULL
// p3: Integer, ordnum of the choreography

R3KFRMM_GETCHOROBJ = 221017;

function mR3KFRMM_GETCHOROBJ(p1, p3) {
  return R3ToJS(  DoA2(this.r3obj, 221017, p1, R3TID_OBJECT, 0, p3, R3TID_INTEGER, 0));
}

// Description: Insert chor object with the given choreography index and attribute.
// p1: Integer, choreograhy index
// p2: Object, animated attribute
// p3: Object, chor object to be inserted

R3KFRMM_INSERT = 221018;

function mR3KFRMM_INSERT(p1, p2, p3) {
  DoA3(this.r3obj, 221018, p1, R3TID_INTEGER, 0, p2, R3TID_OBJECT, 0, p3, R3TID_OBJECT, 0);
}

// Description: Fetch the animation curve for the given choreography and attribute
// Returns: Object, curve or null if the chor is not a key framer or the attribute
//      is not animated
// p1: Integer, attribute id
// p2: Integer, attribute index or -1 for regular attrs
// p3: Tag[], R3CHRYA_Active (chor index), R3KFRMA_Index (array index for array attributes)

R3KFRMM_GETCURVEFORCHOREOGRA = 221019;

function mR3KFRMM_GETCURVEFORCHOREOGRA(p1, p2, p3) {
  return R3ToJS(  Do3(this.r3obj, 221019, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY));
}

// Description: Set input object for the given choreography.
// Returns: Boolean, true if succeeded.
// p1: Integer, choreography
// p3: Tag[], R3KFRMA_InputTag, R3KFRMA_InputMth, R3KFRMA_InputIndex, R3KFRMA_InputSub, R3KFRMA_InputObj

R3KFRMM_SETINPUT = 221020;

function mR3KFRMM_SETINPUT(p1, p3) {
  return   Do2(this.r3obj, 221020, p1, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Delete given points from array attribute.
// p3: String, selected array

R3KFRMM_DELSELECTEDPOINTSFOR = 221022;

function mR3KFRMM_DELSELECTEDPOINTSFOR(p3) {
  DoA(this.r3obj, 221022, p3, R3TID_STRING, 0);
}

// Description: Delete point from array variable.
// Returns: Boolean, true if succeeded.
// p3: Integer, index of the point to be deleted.

R3KFRMM_DELPOINTBYINDEXFORTA = 221023;

function mR3KFRMM_DELPOINTBYINDEXFORTA(p3) {
  return   DoA(this.r3obj, 221023, p3, R3TID_INTEGER, 0);
}

// Description: Insert new point to array variable.
// Returns: Boolean, true if succeeded
// p3: Integer, index for the new point.

R3KFRMM_INSERTPOINTBYINDEXFO = 221024;

function mR3KFRMM_INSERTPOINTBYINDEXFO(p3) {
  return   DoA(this.r3obj, 221024, p3, R3TID_INTEGER, 0);
}

// Description: Assign point 'from' to point 'to'
// p1: Integer, index of the source point
// p2: Integer, index of the target point
// p3: Tag[], tag list containing R3KRMA_Tag (default -1) and R3KFRMA_Index (default -1).

R3KFRMM_ASSIGNPOINTBYINDEXFO = 221025;

function mR3KFRMM_ASSIGNPOINTBYINDEXFO(p1, p2, p3) {
  Do3(this.r3obj, 221025, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// p1: Integer, tag
// p3: Integer, perpoint flag

R3KFRMM_SETTAGPERPOINT = 221026;

function mR3KFRMM_SETTAGPERPOINT(p1, p3) {
  DoA2(this.r3obj, 221026, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Expand the time line to cover the all key frames.

R3KFRMM_ADJUSTBEGINEND = 221027;

function mR3KFRMM_ADJUSTBEGINEND() {
  DoA(this.r3obj, 221027, 0, R3TID_INTEGER, 0);
}

// Description: Scale animation curves in X direction.
// p1: Number, origin
// p3: Number, scale factor

R3KFRMM_SCALECURVESX = 221028;

function mR3KFRMM_SCALECURVESX(p1, p3) {
  DoA2(this.r3obj, 221028, p1, R3TID_FLOAT, 0, p3, R3TID_FLOAT, 0);
}

// Description: Assign index from 'from' to 'to'
// p1: Integer, tag
// p2: Integer, index 'from'
// p3: Integer, index 'to'

R3KFRMM_ASSIGNINDEXFORTAG = 221029;

function mR3KFRMM_ASSIGNINDEXFORTAG(p1, p2, p3) {
  DoA3(this.r3obj, 221029, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Assign tag from 'from' to 'to'
// p1: Integer, tag 'from'
// p2: Integer, tag 'to'
// p3: Integer, index

R3KFRMM_ASSIGNTAGFORINDEX = 221030;

function mR3KFRMM_ASSIGNTAGFORINDEX(p1, p2, p3) {
  DoA3(this.r3obj, 221030, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Weight changed, full recalc.

R3KFRMM_WEIGHTCHANGED = 221031;

function mR3KFRMM_WEIGHTCHANGED() {
  DoA(this.r3obj, 221031, 0, R3TID_INTEGER, 0);
}

// Returns: Boolean, TRUE if the tag is animated in the given choreography
// p1: Integer, choreography index, -1 for the currently active choreography
// p2: Integer, animated tag
// p3: Integer, animated tag index

R3KFRMM_TAGISANIMATEDINCHORE = 221032;

function mR3KFRMM_TAGISANIMATEDINCHORE(p1, p2, p3) {
  return   DoA3(this.r3obj, 221032, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Add new tag to be animated in a single choreography
// p1: Boolean, if true, no curves are created (caller will create anim curves later)

R3KFRMM_ADDTAGINCHOREOGRAPHY = 221033;

function mR3KFRMM_ADDTAGINCHOREOGRAPHY(p1) {
  DoA2(this.r3obj, 221033, p1, R3TID_BOOLEAN, 0, 0, R3TID_INTEGER, 0);
}

// Description: For constr. implementors. Can be called to break the constr. pipeline for    * an attribute.
//      The current value is flushed and the data is freed.
// p1: Integer, tag
// p3: Integer, index or -1 for regular attrs

R3KFRMM_BREAK = 221034;

function mR3KFRMM_BREAK(p1, p3) {
  DoA2(this.r3obj, 221034, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Private, don't call from the user code

R3KFRMM_UPDATETAG = 221036;

function mR3KFRMM_UPDATETAG() {
  DoA(this.r3obj, 221036, 0, R3TID_INTEGER, 0);
}

// Description: Find choreography by name
// Returns: Object, chor object
// p1: Object, attribute object
// p3: String, name

R3KFRMM_FINDCHOR = 221037;

function mR3KFRMM_FINDCHOR(p1, p3) {
  return R3ToJS(  DoA2(this.r3obj, 221037, p1, R3TID_OBJECT, 0, p3, R3TID_STRING, 0));
}

// Description: Create choreography object for the given choreography index
// Returns: Object, chor object
// p1: Object, animated attribute
// p3: Integer, choreography index

R3KFRMM_NEWCHOROBJ = 221038;

function mR3KFRMM_NEWCHOROBJ(p1, p3) {
  return R3ToJS(  DoA2(this.r3obj, 221038, p1, R3TID_OBJECT, 0, p3, R3TID_INTEGER, 0));
}

// Description: Update value of the given attribute object
// Returns: Boolean, true if succeeded
// p1: Object, attribute object
// p2: Object, new value, the actual type is the type of the attribute
// p3: Number, current time

R3KFRMM_TAGOBJCHANGED = 221039;

function mR3KFRMM_TAGOBJCHANGED(p1, p2, p3) {
  return   DoA3(this.r3obj, 221039, p1, R3TID_OBJECT, 0, p2, R3TID_OBJECT, 0, p3, R3TID_FLOAT, 0);
}

// Description: Enumerate timelines
// p1: Object, callback object
// p2: Integer, callback method
// p3: Tag[], R3CHRYA_Active - if -1, all chors are enumerated

R3KFRMM_ENUMTIMELINES = 221040;

function mR3KFRMM_ENUMTIMELINES(p1, p2, p3) {
  Do3(this.r3obj, 221040, p1, R3TID_OBJECT, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Fetch attributes of attribute specified by tag + index.
// Returns: Object, animated attribute object or NULL if the tag is not animated
// p1: Integer, tag
// p2: Integer, tag index for indexed attributes (-1 for regular attributes)
// p3: Tag[], see tags for ADDTAG

R3KFRMM_GETTAG = 221041;

function mR3KFRMM_GETTAG(p1, p2, p3) {
  return R3ToJS(  Do3(this.r3obj, 221041, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY));
}

// Description: For class implementers. A new type of attribute    * may need a special treatement. Attr
//      handler may trigger    * several attributes and handle them in one pass. For example, Matrix transformation
//      components can be animated independently. However, the animation system needs the entire matrix in order
//      to interpolate the transformation.
// Returns: Boolean, true if succeeded
// p2: Integer, priority
// p3: Integer[], null terminated array of attribute ids which should trigger the handler.

R3KFRMCM_REGISTERATTRHANDLER = 221042;

function mR3KFRMCM_REGISTERATTRHANDLER(p2, p3) {
  return   DoA3(this.r3obj, 221042, 0, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Translate selected keys in time.
// p1: Integer, tag
// p2: Integer, tag index (-1 for regular tags)
// p3: Tag[], R3CHRYA_Active, R3KFRMA_SnapToKey, R3KFRMA_Translation

R3KFRMM_TRANSLATESELECTEDTIM = 221043;

function mR3KFRMM_TRANSLATESELECTEDTIM(p1, p2, p3) {
  Do3(this.r3obj, 221043, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Set time value for the selected keys.
// Returns: Boolean, true if succeeded
// p1: Integer, tag
// p2: Integer, tag index (-1 for regular tags)
// p3: Tag[], R3CHRYA_Active, R3KFRMA_Translation

R3KFRMM_SETSELECTEDKEYS = 221044;

function mR3KFRMM_SETSELECTEDKEYS(p1, p2, p3) {
  return   Do3(this.r3obj, 221044, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: R3ACOA_PointSize for all choreographs assiciated with the given attr.
// p1: Integer, tag
// p2: Integer, index,
// p3: Integer, new size

R3KFRMM_UPDATETAGSIZE = 221045;

function mR3KFRMM_UPDATETAGSIZE(p1, p2, p3) {
  DoA3(this.r3obj, 221045, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Given a time, find the next key frame time value
// Returns: Boolean, true if found
// p1: Integer, tag
// p2: Integer, tag index
// p3: Tag[], R3CHRYA_Active specifying the chor and R3KFRMA_Translation specifying the current time value

R3KFRMM_NEXTTIMEKEY = 221046;

function mR3KFRMM_NEXTTIMEKEY(p1, p2, p3) {
  return   Do3(this.r3obj, 221046, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Given a time, find the previous key frame time value
// Returns: Boolean, true if found
// p1: Integer, tag
// p2: Integer, tag index
// p3: Tag[], R3CHRYA_Active specifying the chor and R3KFRMA_Translation specifying the current time value

R3KFRMM_PREVTIMEKEY = 221047;

function mR3KFRMM_PREVTIMEKEY(p1, p2, p3) {
  return   Do3(this.r3obj, 221047, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: See if the object has time sensitive choreographs.
// Returns: Boolean, true if time sensitive choreographs found.

R3KFRMM_ISTIMEBASED = 221048;

function mR3KFRMM_ISTIMEBASED() {
  return   DoA(this.r3obj, 221048, 0, R3TID_INTEGER, 0);
}

// Description: Detach choreographs from their input objects.
// p3: Object, input

R3KFRMM_INVALIDATEINPUT = 221049;

function mR3KFRMM_INVALIDATEINPUT(p3) {
  DoA(this.r3obj, 221049, p3, R3TID_OBJECT, 0);
}

// Description: See if the choreography has input object
// Returns: Boolean, true if input
// p3: Integer, chor index

R3KFRMM_HASINPUT = 221050;

function mR3KFRMM_HASINPUT(p3) {
  return   DoA(this.r3obj, 221050, p3, R3TID_INTEGER, 0);
}

// Description: Copy animated attributes associated with the given source object and choreography to given target
//      object and choreography.
// p1: Object, from object
// p2: Integer, from choreography
// p3: Integer, to choreography

R3KFRMM_COPYANIMATEDATTRS = 221051;

function mR3KFRMM_COPYANIMATEDATTRS(p1, p2, p3) {
  DoA3(this.r3obj, 221051, p1, R3TID_OBJECT, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Create a new key frame .
// p1: Integer, attribute
// p3: Integer, attribute index or -1 for regular attributes

R3KFRMM_NEWKEY = 221052;

function mR3KFRMM_NEWKEY(p1, p3) {
  DoA2(this.r3obj, 221052, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Select / deselect the given attribute
// Returns: Boolean, true if attribute was found
// p1: Integer, tag id
// p2: Integer, tag index, or -1 for regular attrs.
// p3: Boolean, TRUE selects, FALSE deselects

R3KFRMM_SELECTTAG = 221053;

function mR3KFRMM_SELECTTAG(p1, p2, p3) {
  return   DoA3(this.r3obj, 221053, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: Enumerate animated attributes
// p2: Integer, callback method
// p3: Tag[], R3KFRMA_Tag, R3KFRMA_Index, R3KFRMA_Type, R3KFRMA_Selected

R3KFRMM_ENUMATTRS = 221054;

function mR3KFRMM_ENUMATTRS(p2, p3) {
  Do3(this.r3obj, 221054, 0, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: See if the given attribute is selected
// Returns: Boolean, true if selected
// p1: Integer, tag
// p3: Integer, tag index or -1 for regular attrs.

R3KFRMM_TAGISSELECTED = 221055;

function mR3KFRMM_TAGISSELECTED(p1, p3) {
  return   DoA2(this.r3obj, 221055, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Enable keyframing for the tag.
// Returns: Boolean, true if succeeded
// p1: Integer, tag
// p2: Integer, index
// p3: Boolean, true to enable, false to disable

R3KFRMM_TAGENABLEKEYFR = 221056;

function mR3KFRMM_TAGENABLEKEYFR(p1, p2, p3) {
  return   DoA3(this.r3obj, 221056, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: See if the given attribute is enabled for keyframing
// Returns: Boolean, true if enabled
// p1: Integer, attribute id
// p3: Integer, attr index

R3KFRMM_TAGISKEYFRENABLED = 221057;

function mR3KFRMM_TAGISKEYFRENABLED(p1, p3) {
  return   DoA2(this.r3obj, 221057, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Constructors call this to flush attribute they depend on.    *
// Returns: Boolean, true if attribute was managed
// p1: Integer, attribute id
// p3: Integer, index or -1 for regular attrs

R3KFRMM_FLUSH = 221058;

function mR3KFRMM_FLUSH(p1, p3) {
  return   DoA2(this.r3obj, 221058, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Remove constructor
// p1: Object, attribute object
// p3: Object, object to be removed

R3KFRMM_REMOVE = 221059;

function mR3KFRMM_REMOVE(p1, p3) {
  DoA2(this.r3obj, 221059, p1, R3TID_OBJECT, 0, p3, R3TID_OBJECT, 0);
}


R3KFRMM_ISWEIGHTANIMATEABLE = 221060;

function mR3KFRMM_ISWEIGHTANIMATEABLE() {
  DoA(this.r3obj, 221060, 0, R3TID_INTEGER, 0);
}

// Description: Delete the currently selected time keys.
// p1: Integer, attribute
// p2: Integer, attribute index, or -1 for regular attrs
// p3: Integer, choreography index

R3KFRMM_DELSELECTEDKNOTS = 221061;

function mR3KFRMM_DELSELECTEDKNOTS(p1, p2, p3) {
  DoA3(this.r3obj, 221061, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Delete the choreography object associated    * with the given animated attribute and the choreography index.
// p1: Object, animated attribute
// p3: Integer, choreography index

R3KFRMM_DELCHOROBJ = 221062;

function mR3KFRMM_DELCHOROBJ(p1, p3) {
  DoA2(this.r3obj, 221062, p1, R3TID_OBJECT, 0, p3, R3TID_INTEGER, 0);
}

// Description: Fetch the input object of a choreography
// Returns: Object, input object
// p3: Integer, chor index

R3KFRMM_GETINPUTOBJ = 221063;

function mR3KFRMM_GETINPUTOBJ(p3) {
  return R3ToJS(  DoA(this.r3obj, 221063, p3, R3TID_INTEGER, 0));
}

// Description: Set input object for the choreography
// Returns: Boolean, true if chor index is valid
// p1: Integer, chor index
// p3: Object, input object

R3KFRMM_SETINPUTOBJ = 221064;

function mR3KFRMM_SETINPUTOBJ(p1, p3) {
  return   DoA2(this.r3obj, 221064, p1, R3TID_INTEGER, 0, p3, R3TID_OBJECT, 0);
}

// Description: Select keyframes between the given range
// Returns: Integer, number of points selected
// p1: Integer, disabled mask (1 corresponds to x curve etc.)
// p2: Number, start
// p3: Number, end

R3KFRMM_SELECTRANGE = 221065;

function mR3KFRMM_SELECTRANGE(p1, p2, p3) {
  return   DoA3(this.r3obj, 221065, p1, R3TID_INTEGER, 0, p2, R3TID_FLOAT, 0, p3, R3TID_FLOAT, 0);
}

// Description: Shift keyframe curves to start from origin so that they define    * identity transformation there.
// p1: Integer, attribute
// p2: Integer, index or -1 for regular attributes
// p3: Integer, choregraphy

R3KFRMM_SHIFTTOORIGINY = 221066;

function mR3KFRMM_SHIFTTOORIGINY(p1, p2, p3) {
  DoA3(this.r3obj, 221066, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}




R3KFRMA_UserObject = 221500;
function SetR3KFRMA_UserObject(value) {
  R3Set(this.r3obj, R3KFRMA_UserObject, value, R3TID_OBJECT, 0);
}

function GetR3KFRMA_UserObject() {
  return R3ToJS(R3Get(this.r3obj, R3KFRMA_UserObject, R3TID_OBJECT, 0));
}

R3KFRMA_Time = 221501;
function SetR3KFRMA_Time(value) {
  R3Set(this.r3obj, R3KFRMA_Time, value, R3TID_FLOAT, 0);
}

function GetR3KFRMA_Time() {
  return R3Get(this.r3obj, R3KFRMA_Time, R3TID_FLOAT, 0);
}

var R3KFRMA_Tag = 221503; // Integer
var R3KFRMA_Origval = 221504; // Object
var R3KFRMA_IsQuaternionAngle = 221505; // Boolean
var R3KFRMA_NumVals = 221506; // Integer
var R3KFRMA_List = 221511; // Boolean
var R3KFRMA_Relative = 221512; // Boolean
R3KFRMA_NewKeyTolerance = 221513;
function SetR3KFRMA_NewKeyTolerance(value) {
  R3Set(this.r3obj, R3KFRMA_NewKeyTolerance, value, R3TID_FLOAT, 0);
}

var R3KFRMA_WeightTag = 221514; // Integer
var R3KFRMA_InputObj = 221515; // Object
var R3KFRMA_InputTag = 221516; // Integer
var R3KFRMA_InputIndex = 221517; // Integer
var R3KFRMA_InputSub = 221518; // Integer
var R3KFRMA_Chor = 221519; // Integer
var R3KFRMA_PerPoint = 221520; // Boolean
var R3KFRMA_AngleType = 221522; // Integer
var R3KFRMA_InputMth = 221523; // Integer
var R3KFRMA_SnapToKey = 221526; // Boolean
var R3KFRMA_Translation = 221527; // Number
R3KFRMA_AnimatedAttrs = 221529;
function GetR3KFRMA_AnimatedAttrs() {
  return R3Get(this.r3obj, R3KFRMA_AnimatedAttrs, R3TID_LIST, R3TNF_ARRAY);
}

var R3KFRMA_Selected = 221530; // Boolean
var R3KFRMA_ByValue = 221531; // Boolean
var R3KFRMA_InputBeginMth = 221533; // Integer
var R3KFRMA_InputEndMth = 221534; // Integer


function r3Keyframe2 () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_KEYFRAME2, arguments);
   }
   // Methods
   this.ADDTAG=mR3KFRMM_ADDTAG;
   this.TAGISANIMATED=mR3KFRMM_TAGISANIMATED;
   this.TAGCHANGED=mR3KFRMM_TAGCHANGED;
   this.NEWTIME=mR3KFRMM_NEWTIME;
   this.NEWCHOREOGRAPHYTIME=mR3KFRMM_NEWCHOREOGRAPHYTIME;
   this.SETTIMEOVERRIDE=mR3KFRMM_SETTIMEOVERRIDE;
   this.UNSETTIMEOVERRIDE=mR3KFRMM_UNSETTIMEOVERRIDE;
   this.REMOVETAG=mR3KFRMM_REMOVETAG;
   this.GETCURVE=mR3KFRMM_GETCURVE;
   this.RECALCTAG=mR3KFRMM_RECALCTAG;
   this.TIMEOVERRIDE=mR3KFRMM_TIMEOVERRIDE;
   this.CHANGENUMVALSFORTAG=mR3KFRMM_CHANGENUMVALSFORTAG;
   this.ENUMCURVES=mR3KFRMM_ENUMCURVES;
   this.CHANGETAGID=mR3KFRMM_CHANGETAGID;
   this.SETORIGVAL=mR3KFRMM_SETORIGVAL;
   this.GETORIGVAL=mR3KFRMM_GETORIGVAL;
   this.MAKECHOROBJECTS=mR3KFRMM_MAKECHOROBJECTS;
   this.GETCHOROBJ=mR3KFRMM_GETCHOROBJ;
   this.INSERT=mR3KFRMM_INSERT;
   this.GETCURVEFORCHOREOGRA=mR3KFRMM_GETCURVEFORCHOREOGRA;
   this.SETINPUT=mR3KFRMM_SETINPUT;
   this.DELSELECTEDPOINTSFOR=mR3KFRMM_DELSELECTEDPOINTSFOR;
   this.DELPOINTBYINDEXFORTA=mR3KFRMM_DELPOINTBYINDEXFORTA;
   this.INSERTPOINTBYINDEXFO=mR3KFRMM_INSERTPOINTBYINDEXFO;
   this.ASSIGNPOINTBYINDEXFO=mR3KFRMM_ASSIGNPOINTBYINDEXFO;
   this.SETTAGPERPOINT=mR3KFRMM_SETTAGPERPOINT;
   this.ADJUSTBEGINEND=mR3KFRMM_ADJUSTBEGINEND;
   this.SCALECURVESX=mR3KFRMM_SCALECURVESX;
   this.ASSIGNINDEXFORTAG=mR3KFRMM_ASSIGNINDEXFORTAG;
   this.ASSIGNTAGFORINDEX=mR3KFRMM_ASSIGNTAGFORINDEX;
   this.WEIGHTCHANGED=mR3KFRMM_WEIGHTCHANGED;
   this.TAGISANIMATEDINCHORE=mR3KFRMM_TAGISANIMATEDINCHORE;
   this.ADDTAGINCHOREOGRAPHY=mR3KFRMM_ADDTAGINCHOREOGRAPHY;
   this.BREAK=mR3KFRMM_BREAK;
   this.UPDATETAG=mR3KFRMM_UPDATETAG;
   this.FINDCHOR=mR3KFRMM_FINDCHOR;
   this.NEWCHOROBJ=mR3KFRMM_NEWCHOROBJ;
   this.TAGOBJCHANGED=mR3KFRMM_TAGOBJCHANGED;
   this.ENUMTIMELINES=mR3KFRMM_ENUMTIMELINES;
   this.GETTAG=mR3KFRMM_GETTAG;
   this.REGISTERATTRHANDLER=mR3KFRMCM_REGISTERATTRHANDLER;
   this.TRANSLATESELECTEDTIM=mR3KFRMM_TRANSLATESELECTEDTIM;
   this.SETSELECTEDKEYS=mR3KFRMM_SETSELECTEDKEYS;
   this.UPDATETAGSIZE=mR3KFRMM_UPDATETAGSIZE;
   this.NEXTTIMEKEY=mR3KFRMM_NEXTTIMEKEY;
   this.PREVTIMEKEY=mR3KFRMM_PREVTIMEKEY;
   this.ISTIMEBASED=mR3KFRMM_ISTIMEBASED;
   this.INVALIDATEINPUT=mR3KFRMM_INVALIDATEINPUT;
   this.HASINPUT=mR3KFRMM_HASINPUT;
   this.COPYANIMATEDATTRS=mR3KFRMM_COPYANIMATEDATTRS;
   this.NEWKEY=mR3KFRMM_NEWKEY;
   this.SELECTTAG=mR3KFRMM_SELECTTAG;
   this.ENUMATTRS=mR3KFRMM_ENUMATTRS;
   this.TAGISSELECTED=mR3KFRMM_TAGISSELECTED;
   this.TAGENABLEKEYFR=mR3KFRMM_TAGENABLEKEYFR;
   this.TAGISKEYFRENABLED=mR3KFRMM_TAGISKEYFRENABLED;
   this.FLUSH=mR3KFRMM_FLUSH;
   this.REMOVE=mR3KFRMM_REMOVE;
   this.ISWEIGHTANIMATEABLE=mR3KFRMM_ISWEIGHTANIMATEABLE;
   this.DELSELECTEDKNOTS=mR3KFRMM_DELSELECTEDKNOTS;
   this.DELCHOROBJ=mR3KFRMM_DELCHOROBJ;
   this.GETINPUTOBJ=mR3KFRMM_GETINPUTOBJ;
   this.SETINPUTOBJ=mR3KFRMM_SETINPUTOBJ;
   this.SELECTRANGE=mR3KFRMM_SELECTRANGE;
   this.SHIFTTOORIGINY=mR3KFRMM_SHIFTTOORIGINY;

   // Attributes
   this.GetUserObject=GetR3KFRMA_UserObject;
   this.SetUserObject=SetR3KFRMA_UserObject;
   this.GetTime=GetR3KFRMA_Time;
   this.SetTime=SetR3KFRMA_Time;
   this.SetNewKeyTolerance=SetR3KFRMA_NewKeyTolerance;
   this.GetAnimatedAttrs=GetR3KFRMA_AnimatedAttrs;
}

r3Keyframe2.prototype=new r3Choreography;
// r3keyfr2.h_H